using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using System.Data;
using System.Data.Common;
using Vb = Microsoft.VisualBasic;
using System.Windows.Forms;
using System.Collections;
using ACFramework;

namespace ACSeguridad
{
   public class ACGenerarMenu
   {
      #region Variables
      private ACTypeAlgorithm m_algorithm;
      private ACDataConexion m_dataconexion;
      private ACDataUsuario m_datausuario;

      bool m_empresa;
      bool m_respuesta;

      private EEmpresas c_empresa;
      private List<EEmpresas> l_empresa;

      #endregion

      #region Propiedades

      public EEmpresas Empresa
      {
         get { return c_empresa; }
         set { c_empresa = value; }
      }

      public string ACNombreEmpresa
      {
         get { return m_dataconexion.NombreEmpresa; }
         set { m_dataconexion.NombreEmpresa = value; }
      }
      public string ACValueMenu
      {
         get { return m_valueMenu; }
         set { m_valueMenu = value; }
      }
      public bool Respuesta
      {
         get { return m_respuesta; }
         set { m_respuesta = value; }
      }

      public List<EEmpresas> ListEmpresas
      {
         get { return l_empresa; }
         set { l_empresa = value; }
      }
      #endregion

      #region Utilitarios

      private DateTime getDateTime()
      {
         DataTable x_datos = new DataTable();
         try
         {
            DAEnterpriseValidate.AsignarProcedure("select GetDate()", CommandType.Text);
            x_datos = DAEnterpriseValidate.ExecuteDataSet().Tables[0];
            DateTime _fecha = (DateTime)x_datos.Rows[0][0];
            return _fecha;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      #endregion

      #region Metodos Publicos
      /// <summary>
      /// Hacer Visible todos los items del menu
      /// </summary>
      /// <param name="_menu">El Objeto Menu, enviado por referencia</param>
      /// <param name="_option">Opcion VISIBLE del item [True, False]</param>
      public static void setMenuVisibleItems(ref System.Windows.Forms.MenuStrip _menu, bool _option)
      {
         //for (int i = 0; i < _menu.Items.Count; i++)
         foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
         {
            Item.Enabled = true;
            setMenuVisibleItems(Item.DropDownItems, _option);
         }
      }

      /// <summary>
      /// Hacer (No)VISIBLE los items del menu, metodo usado para la recursividad, y recorrido del menu
      /// </summary>
      /// <param name="_Item">Item del menu</param>
      /// <param name="_estado">Estado que se le dara al item</param>
      private static void setMenuVisibleItems(System.Windows.Forms.ToolStripItemCollection _Item, bool _estado)
      {
         try
         {
            for (int i = 0; i < _Item.Count; i++)
            {
               if (!(_Item[i] is ToolStripSeparator))
               {
                  _Item[i].Visible = _estado;
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Deshabilitar todos los items del menu
      /// </summary>
      /// <param name="_menu">Objteto Menu</param>
      public static void setMenuDisabled(ref System.Windows.Forms.MenuStrip _menu)
      {
         foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
         {
            Item.Enabled = false;
         }
      }

      /// <summary>
      /// Deshabilitar todos los items del menu
      /// </summary>
      /// <param name="_menu">Objeto Menu</param>
      public static void setMenuDisabledItems(ref System.Windows.Forms.MenuStrip _menu)
      {
         //for (int i = 0; i < _menu.Items.Count; i++)
         foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
         {
            Item.Enabled = true;
            setMenuItems(Item.DropDownItems, false);
         }
      }

      /// <summary>
      /// Habilitar todas las opciones del menu
      /// </summary>
      /// <param name="_menu">Objeto menu</param>
      public static void setMenuEnabledItems(ref System.Windows.Forms.MenuStrip _menu)
      {
         //for (int i = 0; i < _menu.Items.Count; i++)
         foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
         {
            Item.Enabled = true;
            setMenuItems(Item.DropDownItems, true);
         }
      }

      /// <summary>
      /// Metodo para habilitar items, metodo usado para la recursividad del recorrido
      /// </summary>
      /// <param name="_Item">Item del menu</param>
      /// <param name="_estado">Estado que tomara el item del menu</param>
      private static void setMenuItems(System.Windows.Forms.ToolStripItemCollection _Item, bool _estado)
      {
         try
         {
            for (int i = 0; i < _Item.Count; i++)
            {
               if (!(_Item[i] is ToolStripSeparator))
               {
                  _Item[i].Enabled = _estado;
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Habilitar todas las opciones del menu
      /// </summary>
      /// <param name="_menu">Objeto menu</param>
      public static void setMenuEnabled(ref System.Windows.Forms.MenuStrip _menu)
      {
         foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
         {
            Item.Enabled = true;
         }
      }

      /// <summary>
      /// Habilitar menu, metodo para la recursividad
      /// </summary>
      /// <param name="_menu">Objeto Menu</param>
      /// <param name="_textItem"></param>
      private void setMenuEnabled(ref System.Windows.Forms.MenuStrip _menu, string _textItem)
      {
         try
         {
            int i = 1;
            foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
            {
               if (Item.Text == _textItem)
               {
                  Item.Enabled = true;
                  return;
               }
               else
               {
                  Item.Enabled = true;
                  if (Item.DropDownItems.Count > 0)
                  {
                     setMenuEnabled(Item.DropDownItems, _textItem);
                  }
               }
               i++;
            }
         }
         catch (Exception ex)
         {
            ACDialogos.MostrarMensajeError("Permisos del Sistema", "No puede otorgar permisos, revise el problema y vuelva a intentarlo", ex);
         }
      }

      /// <summary>
      /// Habilitar menu, metodo para la recursividad
      /// </summary>
      /// <param name="_Item"></param>
      /// <param name="_textItem"></param>
      private void setMenuEnabled(System.Windows.Forms.ToolStripItemCollection _Item, string _textItem)
      {
         try
         {
            for (int i = 0; i < _Item.Count; i++)
            {
               if (!(_Item[i] is ToolStripSeparator))
               {
                  if (_Item[i].Text == _textItem)
                  {
                     _Item[i].Enabled = true;
                     return;
                  }
                  else
                  {
                     _Item[i].Enabled = true;
                     if (((ToolStripMenuItem)(_Item[i])).DropDownItems.Count > 0)
                     {
                        setMenuEnabled(((ToolStripMenuItem)(_Item[i])).DropDownItems, _textItem);
                     }
                  }
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      #endregion

      #region Constructores

      /// <summary>
      /// Constructor que recibe datos de conexion y usuario de validacion para construir el menu de usuario en la base de datos
      /// de administracion de la aplicacion NextAdmin, o descargar el menu para aplicar permisos al usuario que esta validandose
      /// hay que resaltar que se utiliza el algoritmo por defecto que es el MD5
      /// </summary>
      /// <param name="_dc">Clase que contiene los datos de conexion</param>
      /// <param name="_du">Datos del usuario que quiere validarse en la base de datos</param>
      /// <param name="_menu">Objeto tipo MenuStrip a ser recorrido para ser subido o bajado a la base de datos</param>
      /// <param name="_opt">Tipo de ejecucion que se utlizara, si se el menu enviado se subira a la base de datos de administracion 
      /// o se descargara el menu de usuario para dar permisos a los usuarios</param>
      public ACGenerarMenu(ACDataConexion _dc, ACDataUsuario _du, ref System.Windows.Forms.MenuStrip _menu, ACTypeQueryMenu _opt, string m_formatofecha)
      {
         try
         {
            DAEnterpriseValidate.Instanciar(_dc.Servidor, _dc.BaseDatos, _dc.UsuarioBD, _dc.PasswordBD);
            m_algorithm = _dc.Algoritmo;
            m_dataconexion = _dc;
            m_datausuario = _du;
            m_dataconexion.NombreEmpresa = (_dc.NombreEmpresa == null ? _dc.BaseDatos.ToString() : _dc.NombreEmpresa);
            switch (_opt)
            {
               // Subir el Menu a la Base de Datos
               case ACTypeQueryMenu.generarMenu:
                  m_respuesta = GenerarMenu(ref _menu, m_formatofecha);
                  break;
               // Descargar el menu de la base de datos para asignar los permisos
               case ACTypeQueryMenu.asignarMenu:
                  m_respuesta = AsignarMenu(ref _menu, m_formatofecha);
                  break;
               default:
                  break;
            }
            // Cargar empresa
            Hashtable x_where = new Hashtable();
            x_where.Add("EMPR_Codigo", new ACWhere(m_datausuario.EMPR_Codigo, ACWhere.TipoWhere.Igual, true));
            ACGenerador<EEmpresas> _join = new ACGenerador<EEmpresas>(m_formatofecha);
            string sql = String.Format("Select * from [dbo].[Empresas] Where {0}", _join.getWhere(x_where, true));
            DAEnterpriseValidate.AsignarProcedure(sql, System.Data.CommandType.Text);
            c_empresa = new EEmpresas();
            using (DbDataReader reader = (DbDataReader)DAEnterpriseValidate.ExecuteDataReader())
            {
               if (reader.HasRows)
               {
                  reader.Read();
                  ACEsquemas.ACCargarEsquema(reader, c_empresa);
                  c_empresa.Instanciar(ACEInstancia.Consulta);
               }
            }
            sql = String.Format("Select * from [dbo].[Empresas]");
            DAEnterpriseValidate.AsignarProcedure(sql, System.Data.CommandType.Text);
            l_empresa = new List<EEmpresas>();
            using (DbDataReader reader = (DbDataReader)DAEnterpriseValidate.ExecuteDataReader())
            {
               if (reader.HasRows)
               {
                  while (reader.Read())
                  {
                     EEmpresas _empresa = new EEmpresas();
                     ACEsquemas.ACCargarEsquema(reader, _empresa);
                     _empresa.Instanciar(ACEInstancia.Consulta);
                     l_empresa.Add(_empresa);
                  }
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Constructor que recibe datos de conexion y usuario de validacion para construir el menu de usuario en la base de datos
      /// de administracion de la aplicacion NextAdmin, o descargar el menu para aplicar permisos al usuario que esta validandose
      /// hay que resaltar que se utiliza el algoritmo por defecto que es el MD5
      /// </summary>
      /// <param name="_dc">Clase que contiene los datos de conexion</param>
      /// <param name="_du">Datos del usuario que quiere validarse en la base de datos</param>
      /// <param name="_menu">Objeto tipo MenuStrip a ser recorrido para ser subido o bajado a la base de datos</param>
      /// <param name="_opt">Tipo de ejecucion que se utlizara, si se el menu enviado se subira a la base de datos de administracion 
      /// o se descargara el menu de usuario para dar permisos a los usuarios</param>
      public ACGenerarMenu(ACDataConexion _dc, ACDataUsuario _du, ref System.Windows.Forms.MenuStrip _menu, ACTypeQueryMenu _opt, ACTypeAlgorithm x_algorithm, string m_formatofecha)
      {
         try
         {
            DAEnterpriseValidate.Instanciar(_dc.Servidor, _dc.BaseDatos, _dc.UsuarioBD, _dc.PasswordBD);
            m_algorithm = x_algorithm;
            switch (_opt)
            {
               case ACTypeQueryMenu.generarMenu:
                  m_respuesta = GenerarMenu(ref _menu, m_formatofecha);
                  break;
               case ACTypeQueryMenu.asignarMenu:
                  m_respuesta = AsignarMenu(ref _menu, m_formatofecha);
                  break;
               default:
                  break;
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Constructor que recibe datos de conexiion y usuario de validacion para construir el menu, usando una lista con el tipo 
      /// EPlantilla llenado para ser subido a la base de datos de administracion
      /// </summary>
      /// <param name="_dc">Clase que contiene los datos de conexion</param>
      /// <param name="_du">Datos del usuario que quiere validarse en la base de datos</param>
      /// <param name="_menu">Lista de tipo EPlantilla con los datos del menu</param>
      public ACGenerarMenu(ACDataConexion _dc, ACDataUsuario _du, List<EPlantillas> _menu, string m_formatofecha)
      {
         try
         {
            DAEnterpriseValidate.Instanciar(_dc.Servidor, _dc.BaseDatos, _dc.UsuarioBD, _dc.PasswordBD);
            m_algorithm = _dc.Algoritmo;
            m_respuesta = GenerarMenu(ref _menu, m_datausuario.USER_CodUsr, m_formatofecha);
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      #endregion

      #region Menu

      #region generar el menu
      private string m_valueMenu;
      private List<EPlantillas> m_ListPlantillas;
      private List<EUsuariosPlantillas> m_ListPtlaUsers;

      /// <summary>
      /// Genera el menu, pasando todos sus valores a una lista
      /// </summary>
      /// <param name="_menu">El Objeto tipo MenuStrip enviado por referencia</param>
      private bool GenerarMenu(ref System.Windows.Forms.MenuStrip _menu, string m_formatofecha)
      {
         try
         {
            m_valueMenu = "";
            // Crear el primer item del menu, el padre de todo el Menu
            EPlantillas _plantilla = new EPlantillas();
            cargarPlantilla(ref _plantilla, 0, 0, (m_dataconexion.NombreEmpresa == "" ? m_datausuario.APLI_Codigo : m_dataconexion.NombreEmpresa), "A", "Base");
            m_ListPlantillas = new List<EPlantillas>();
            m_ListPlantillas.Add(_plantilla);

            int i = 1;
            // Cargar recursivamente los valores del menu
            foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
            {
               m_valueMenu += String.Format("{0}\t{1}{2}", i, Item.Text, Environment.NewLine);
               EPlantillas m_plantilla = new EPlantillas();
               cargarPlantilla(ref m_plantilla, i, 0, Item.Text, "A", Item.Name);
               m_ListPlantillas.Add(m_plantilla);
               if (Item.DropDownItems.Count > 0)
               {
                  GenerarMenu(Item.DropDownItems, ref m_valueMenu, ref i, ref m_ListPlantillas);
               }
               i++;
            }

            DAEnterpriseValidate.BeginTran();
            if (GenerarMenu(ref m_ListPlantillas, m_datausuario.USER_CodUsr, m_formatofecha))
            {
               DAEnterpriseValidate.CommintTran();
               return true;
            }
            else
            {
               DAEnterpriseValidate.RollBackTran();
               return false;
            }
         }
         catch (Exception ex)
         {
            DAEnterpriseValidate.RollBackTran();
            foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
            {
               Item.Enabled = false;
            }
            ACDialogos.MostrarMensajeError("Generador de Menu's", "No puede generar el menu, revise el detalle y vuelva a intentarlo", ex);
         }
         return false;
      }

      /// <summary>
      /// Funcion que se utiliza recursivamente para poder obtener todos los niveles del menus, e ingresarlos en una lista para
      /// ser procesados posteriormente
      /// </summary>
      /// <param name="_Item">Hijo del menu</param>
      /// <param name="_valueMenu">Contiene el nombre del menu</param>
      /// <param name="order">Contiene el orden en que se encuentra cada item encontrado</param>
      /// <param name="_list">Lista que contiene todos los items del menu</param>
      private void GenerarMenu(System.Windows.Forms.ToolStripItemCollection x_Item, ref string x_valueMenu, ref int x_order, ref List<EPlantillas> x_list)
      {
         try
         {
            int padre = x_order;
            for (int i = 0; i < x_Item.Count; i++)
            {
               if (!(x_Item[i] is ToolStripSeparator))
               {
                  x_order++;
                  x_valueMenu += padre.ToString() + "." + x_order.ToString() + "\t" + x_Item[i].Text + "\n";
                  EPlantillas m_plantilla = new EPlantillas();
                  string _estado = "A";
                  if (x_Item[i].Tag != null)
                  {
                     if (x_Item[i].Tag.ToString().Equals(""))
                        _estado = x_Item[i].Tag.ToString().Trim().Substring(0, 1);
                  }
                  cargarPlantilla(ref m_plantilla, x_order, padre, x_Item[i].Text, _estado, x_Item[i].Name);
                  x_list.Add(m_plantilla);

                  if (((ToolStripMenuItem)(x_Item[i])).DropDownItems.Count > 0)
                  {
                     GenerarMenu(((ToolStripMenuItem)(x_Item[i])).DropDownItems, ref x_valueMenu, ref x_order, ref x_list);
                  }
               }
               else if (x_Item[i] is ToolStripSeparator)
               {
                  x_order++;
                  x_valueMenu += padre.ToString() + "." + x_order.ToString() + "\t- \n";
                  EPlantillas m_plantilla = new EPlantillas();
                  cargarPlantilla(ref m_plantilla, x_order, padre, "-", "L", x_Item[i].Name);
                  x_list.Add(m_plantilla);
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Funcion que permite cargar la clase EPlantilla para que contenga todos los valores requeridos para posteriormente
      /// ser ingresado en la base de datos
      /// </summary>
      /// <param name="_plantilla">Plantilla que tiene que rellenar con los datos comunes</param>
      /// <param name="key">Llave principal de la plantilla</param>
      /// <param name="relative">Llave relativa de la plantilla</param>
      /// <param name="text">Nombre del menu</param>
      /// <param name="activo">Estado de la plantilla</param>
      private void cargarPlantilla(ref EPlantillas x_plantilla, int x_key, int x_relative, string x_text, string x_activo, string x_codigo)
      {
         try
         {
            x_plantilla.APLI_Codigo = m_datausuario.APLI_Codigo;
            x_plantilla.PTLA_Activo = x_activo;
            x_plantilla.PTLA_Key = x_key;
            x_plantilla.PTLA_Relative = x_relative;
            x_plantilla.PTLA_Text = x_text;
            x_plantilla.PTLA_UsrCrea = m_datausuario.USER_CodUsr;
            x_plantilla.EMPR_Codigo = m_datausuario.EMPR_Codigo;
            x_plantilla.PTLA_Codigo = x_codigo;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Funcion que recorre el listado de plantillas creado para ser grabado en la base de datos de administracion
      /// </summary>
      /// <param name="_menu">Lista a ser grabada</param>
      private bool GenerarMenu(ref List<EPlantillas> _menu, string x_usuario, string m_formatofecha)
      {
         try
         {
            DateTime _fecha = getDateTime();
            foreach (EPlantillas Item in _menu)
            {
               grabarMenu(Item, x_usuario, _fecha, m_formatofecha);
            }
            return true;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Procedimiento que graba en la base de datos todo el menu
      /// </summary>
      /// <param name="_registro">Plantilla de registro</param>
      private void grabarMenu(EPlantillas _registro, string x_usuario, DateTime x_fecha, string m_formatofecha)
      {
         try
         {
            _registro.PTLA_UsrCrea = x_usuario;
            _registro.PTLA_FecCrea = x_fecha;
            ACFramework.ACGenerador<EPlantillas> _insert = new ACFramework.ACGenerador<EPlantillas>(m_formatofecha);
            string sql = genSQLInsert("dbo", "PlantillasMenu", _registro, x_usuario, x_fecha, m_formatofecha);  //_insert.getInsert("dbo", "PlantillasMenu", _registro);
            DAEnterpriseValidate.AsignarProcedure(sql, System.Data.CommandType.Text);
            DAEnterpriseValidate.ExecuteNonQuery();
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      private string genSQLInsert(string x_esquema, string x_tablas, EPlantillas x_registro, string x_usuario, DateTime x_fecha, string m_formatofecha)
      {
         try
         {
            string sql = String.Format("INSERT INTO {0}.{1}({2}", x_esquema, x_tablas, Environment.NewLine);
            sql += " APLI_Codigo";
            sql += ",EMPR_Codigo";
            sql += ",PTLA_Codigo";
            sql += ",PTLA_Key";
            sql += ",PTLA_Relative";
            sql += ",PTLA_Text";
            sql += ",PTLA_Activo";
            sql += ",PTLA_UsrCrea";
            sql += ",PTLA_FecCrea";
            sql += ") VALUES (";
            sql += String.Format(" '{0}'{1}", x_registro.APLI_Codigo, Environment.NewLine);
            sql += String.Format(",'{0}'{1}", x_registro.EMPR_Codigo, Environment.NewLine);
            sql += String.Format(",'{0}'{1}", x_registro.PTLA_Codigo, Environment.NewLine);
            sql += String.Format(",{0}{1}", x_registro.PTLA_Key, Environment.NewLine);
            sql += String.Format(",{0}{1}", x_registro.PTLA_Relative, Environment.NewLine);
            sql += String.Format(",'{0}'{1}", x_registro.PTLA_Text, Environment.NewLine);
            sql += String.Format(",'{0}'{1}", x_registro.PTLA_Activo, Environment.NewLine);
            sql += String.Format(",'{0}'{1}", x_usuario, Environment.NewLine);
            sql += String.Format(",'{0}'{1}", x_fecha.ToString(m_formatofecha), Environment.NewLine);
            sql += ")";

            return sql;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      #endregion

      #region habilitar/dehabilitar el menu

      /// <summary>
      /// Procedimiento para obtener los valores del menu
      /// </summary>
      /// <returns>Valor para verificar que se cargo todo el menu correctamente</returns>
      private bool ObtenerMenu(string m_formatofecha)
      {
         m_valueMenu = "";
         try
         {
            m_ListPtlaUsers = new List<EUsuariosPlantillas>();

            // Obtener la lista con los permisos
            string sql = "";

            List<ACJoin> x_join = new List<ACJoin>();
            x_join.Add(new ACJoin("dbo", "PlantillasMenu", "Pla", ACJoin.TipoJoin.Inner
                                 , new ACCampos[] { new ACCampos("APLI_Codigo", "APLI_Codigo"), new ACCampos("EMPR_Codigo", "EMPR_Codigo"), new ACCampos("PTLA_Codigo", "PTLA_Codigo") }
                                 , new ACCampos[] { new ACCampos("PTLA_Key", "PTLA_Key"), new ACCampos("PTLA_Relative", "PTLA_Relative") }));
            x_join.Add(new ACJoin("dbo", "Usuarios", "Us", ACJoin.TipoJoin.Inner
                                , new ACCampos[] { new ACCampos("USER_IdUser", "USER_IdUser") }
                                , new ACCampos[] { new ACCampos("USER_DNI", "USER_DNI") }));
            Hashtable x_where = new Hashtable();

            x_where.Add("APLI_Codigo", new ACWhere(m_datausuario.APLI_Codigo, ACWhere.TipoWhere.Igual, true));
            x_where.Add("EMPR_Codigo", new ACWhere(m_datausuario.EMPR_Codigo, ACWhere.TipoWhere.Igual, true));
            x_where.Add("USER_DNI", new ACWhere(m_datausuario.USER_DNI, "Us", "System.String", ACWhere.TipoWhere.Igual, true));
            ACGenerador<EUsuariosPlantillas> _join = new ACGenerador<EUsuariosPlantillas>(m_formatofecha);
            sql += _join.getJoin("dbo", "UsuariosPlantillas", x_join, x_where);

            // Ejecutar la consulta para obtener el listado
            DAEnterpriseValidate.AsignarProcedure(sql, System.Data.CommandType.Text);
            using (DbDataReader reader = (DbDataReader)DAEnterpriseValidate.ExecuteDataReader())
            {
               if (reader.HasRows)
               {
                  ACEsquemas _esquemas = new ACEsquemas(new EUsuariosPlantillas());
                  while (reader.Read())
                  {
                     EUsuariosPlantillas _plantillasmenu = new EUsuariosPlantillas();
                     _esquemas.ACCargarEsquemas(reader, _plantillasmenu);
                     _plantillasmenu.Instanciar(ACEInstancia.Consulta);
                     m_ListPtlaUsers.Add(_plantillasmenu);
                  }
                  return true;
               }
               else
               { return false; }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
         return (m_ListPlantillas.Count > 0 ? true : false);
      }

      /// <summary>
      /// Dar el permiso al item, segun el valor dado por la base de datos.
      /// </summary>
      /// <param name="_estado">Estado: I=Inactivo, A=Activo, V=No Visible</param>
      /// <param name="_item">Item del menu</param>
      /// <param name="_valueMenu">Valor del menu</param>
      /// <param name="order">Parametro para el orden del menu</param>
      private void setAccessMenu(System.Windows.Forms.ToolStripMenuItem _item, ref string _valueMenu, ref int x_order)
      {
         string _estado = "";
         try
         {
            ACFiltrador<EUsuariosPlantillas> _filter = new ACFiltrador<EUsuariosPlantillas>();
            _filter.ACFiltro = String.Format("PTLA_Codigo={0}", _item.Name);
            _filter.ACFiltrar(m_ListPtlaUsers);
            if (_filter.ACListaFiltrada.Count > 0)
            { _estado = _filter.ACListaFiltrada[0].PUSR_Activo; }
            else
            { _estado = "I"; }

            switch (_estado)
            {
               case "I":
                  _item.Enabled = false;
                  setMenu(_item.DropDownItems, ref m_valueMenu, ref x_order);
                  if (_item.DropDownItems.Count > 0)
                  {
                     setMenu(_item.DropDownItems, ref m_valueMenu, ref x_order, false);
                  }
                  break;
               case "A":
                  _item.Enabled = true;
                  _item.Visible = true;
                  _item.Enabled = true;
                  if (_item.DropDownItems.Count > 0)
                  {
                     setMenu(_item.DropDownItems, ref m_valueMenu, ref x_order);
                  }
                  break;
               case "V":
                  _item.Enabled = false;
                  _item.Visible = false;
                  break;
               default:
                  _item.Enabled = false;
                  break;
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Procediiento para colocar la propiedad respectiva a cada Item del menu, segun los permisos que tenga el usuario que 
      /// valido su cuenta.
      /// </summary>
      /// <param name="_menu">Objeto MenuStrip que sera recorrido para habilitar y deshabilitar items.</param>
      private bool AsignarMenu(ref System.Windows.Forms.MenuStrip _menu, string m_formatofecha)
      {
         try
         {
            if (ObtenerMenu(m_formatofecha))
            {
               int i = 1;
               foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
               {
                  m_valueMenu += String.Format("{0}\t{1} \n", i, Item.Text);
                  setAccessMenu(Item, ref m_valueMenu, ref i);
                  i++;
               }
               m_empresa = true;
               return true;
            }
            else
            {
               m_empresa = false;
               foreach (System.Windows.Forms.ToolStripMenuItem Item in _menu.Items)
               {
                  Item.Enabled = false;
               }
               ACDialogos.MostrarMensajeInformacion("Información", "Ud. no tiene Acceso a la empresa seleccionada");
               return false;
            }
         }
         catch (Exception ex)
         {
            ACDialogos.MostrarMensajeError("Permisos del Sistema", "No puede otorgar permisos, revise el problema y vuelva a intentarlo", ex);
         }
         return false;
      }

      /// <summary>
      /// Procedimiento recursivo que ingresara en todos los Items hijos del menu para otorgarles los permisos correspondientes.
      /// </summary>
      /// <param name="_Item">Contiene un menu o puede ser un valir</param>
      /// <param name="_valueMenu"></param>
      /// <param name="order">Llave por la cual se rige los permisos que se estan dando</param>
      private void setMenu(System.Windows.Forms.ToolStripItemCollection _Item, ref string _valueMenu, ref int x_order)
      {
         string estado;
         try
         {
            int padre = x_order;
            for (int i = 0; i < _Item.Count; i++)
            {
               if (!(_Item[i] is ToolStripSeparator))
               {
                  ACFiltrador<EUsuariosPlantillas> _filter = new ACFiltrador<EUsuariosPlantillas>();
                  _filter.ACFiltro = "PTLA_Codigo=" + ((ToolStripMenuItem)(_Item[i])).Name;
                  _filter.ACFiltrar(m_ListPtlaUsers);
                  if (_filter.ACListaFiltrada.Count > 0)
                  { estado = _filter.ACListaFiltrada[0].PUSR_Activo; }
                  else
                  { estado = "I"; }

                  _valueMenu += padre.ToString() + "." + x_order.ToString() + "\t" + _Item[i].Text + "\n";
                  if (estado == "I")
                  {
                     _Item[i].Enabled = false;
                     if (((ToolStripMenuItem)(_Item[i])).DropDownItems.Count > 0)
                     {
                        setMenu(((ToolStripMenuItem)(_Item[i])).DropDownItems, ref _valueMenu, ref x_order, false);
                     }
                  }
                  else if (estado == "A")
                  {
                     _Item[i].Enabled = true;
                     _Item[i].Visible = true;
                     if (((ToolStripMenuItem)(_Item[i])).DropDownItems.Count > 0)
                     {
                        setMenu(((ToolStripMenuItem)(_Item[i])).DropDownItems, ref _valueMenu, ref x_order);
                     }
                  }
                  else if (estado == "V")
                  {
                     _Item[i].Enabled = false;
                     _Item[i].Visible = false;
                  }
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      private void setMenu(System.Windows.Forms.ToolStripItemCollection _Item, ref string _valueMenu, ref int x_order, bool x_active)
      {
         string estado;
         try
         {
            int padre = x_order;
            for (int i = 0; i < _Item.Count; i++)
            {
               if (!(_Item[i] is ToolStripSeparator))
               {
                  ACFiltrador<EUsuariosPlantillas> _filter = new ACFiltrador<EUsuariosPlantillas>();
                  _filter.ACFiltro = "PTLA_Codigo=" + ((ToolStripMenuItem)(_Item[i])).Name;
                  _filter.ACFiltrar(m_ListPtlaUsers);
                  if (_filter.ACListaFiltrada.Count > 0)
                  { estado = _filter.ACListaFiltrada[0].PUSR_Activo; }
                  else
                  { estado = "I"; }

                  _valueMenu += padre.ToString() + "." + x_order.ToString() + "\t" + _Item[i].Text + "\n";
                  if (estado == "I")
                  {
                     _Item[i].Enabled = x_active;
                     if (((ToolStripMenuItem)(_Item[i])).DropDownItems.Count > 0)
                     {
                        setMenu(((ToolStripMenuItem)(_Item[i])).DropDownItems, ref _valueMenu, ref x_order, x_active);
                     }
                  }
                  else if (estado == "A")
                  {
                     _Item[i].Enabled = x_active;
                     _Item[i].Visible = true;
                     if (((ToolStripMenuItem)(_Item[i])).DropDownItems.Count > 0)
                     {
                        setMenu(((ToolStripMenuItem)(_Item[i])).DropDownItems, ref _valueMenu, ref x_order, x_active);
                     }
                  }
                  else if (estado == "V")
                  {
                     _Item[i].Enabled = false;
                     _Item[i].Visible = false;
                  }
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Procedimiento que devuelve el estado en el que se encuentra un Item del menu, para su respectiva habilitacion/inhabilitacion
      /// </summary>
      /// <param name="key">Campo llave con el que se lo buscara</param>
      /// <param name="relative">Campo relativo que tambien sirve para su busqueda</param>
      /// <returns>El estado del Item buscado</returns>
      private string getEstado(int key, int relative)
      {
         try
         {
            _key = key;
            _relative = relative;
            string estado = "";
            EPlantillas tmp = m_ListPlantillas.Find(getEstado);
            if (tmp == null)
               estado = "A";
            else
            {
               estado = tmp.PTLA_Activo;
            }
            return estado;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      private int _key;
      private int _relative;

      /// <summary>
      /// Obtener el estado del menu, segun plantilla de la base de datos.
      /// </summary>
      /// <param name="_list"></param>
      /// <returns></returns>
      private bool getEstado(EPlantillas _list)
      {
         if (_list.PTLA_Key == _key && _list.PTLA_Relative == _relative)
         {
            return true;
         }
         else
         {
            return false;
         }
      }

      /// <summary>
      /// Carga el esquema de la plantilla.
      /// </summary>
      /// <param name="x_fila">Registro a ser cargado</param>
      /// <param name="x_eplantillas">Plantilla a ser cargadas</param>

      #endregion
      #endregion

   }
}
